package com.demo.java.OD501_550.OD514;

import java.util.Scanner;

/**
 * @author bug菌
 * @Source 公众号：猿圈奇妙屋
 * @des： 【特殊的加密算法(C卷-100分)】问题
 * @url： https://blog.csdn.net/weixin_43970743/article/details/146481326
 */
public class OdMain {
    // 用于记录四个方向的移动
    public static int[][] directions = {{-1, 0}, {0, -1}, {0, 1}, {1, 0}};
    public static String result;  // 用于存储搜索路径

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();  // 目标数字序列的长度
        int[] nums = new int[n];  // 存储目标数字序列
        for (int i = 0; i < n; i++) {
            nums[i] = in.nextInt();  // 读取目标数字序列
        }

        int m = in.nextInt();  // 矩阵的尺寸
        int[][] matrix = new int[m][m];  // 创建矩阵
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < m; j++) {
                matrix[i][j] = in.nextInt();  // 读取矩阵内容
            }
        }

        int flag = 0;  // 标记是否找到路径
        // 遍历矩阵中的每一个位置，开始 DFS 搜索
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < m; j++) {
                result = "";
                if (matrix[i][j] == nums[0] && dfs(i, j, 0, n, m, nums, matrix)) {  // 如果找到第一个匹配的数字
                    flag = 1;
                    break;
                }
            }
            if (flag == 1) {
                break;
            }
        }

        // 输出搜索结果
        if (flag == 1) {
            System.out.println(result.substring(0, result.length() - 1));  // 输出路径，去掉最后一个空格
        } else {
            System.out.println("error");  // 如果没有找到路径，输出 error
        }
    }

    // 辅助方法：用于将输入的字符串分割成整数数组
    public static int[] split(String input_str, String chars) {
        String[] tmp2 = input_str.split(chars);
        int[] results = new int[tmp2.length];
        for (int i = 0; i < tmp2.length; i++) {
            results[i] = Integer.parseInt(tmp2[i]);
        }
        return results;
    }

    // DFS 搜索路径
    public static boolean dfs(int x, int y, int index, int n, int m, int[] nums, int[][] matrix) {
        result += x + " " + y + " ";  // 记录当前位置
        if (index == n - 1) {  // 如果已经找到了完整的数字序列
            return true;
        }

        int record = matrix[x][y];  // 记录当前位置的数字
        matrix[x][y] = Integer.MAX_VALUE;  // 标记当前位置已访问
        int i = 0;
        // 遍历四个方向进行搜索
        while (true) {
            if (i >= 4) {
                break;
            } else {
                int new_x = x + directions[i][0];
                int new_y = y + directions[i][1];
                // 如果新位置越界或数字不匹配，继续检查其他方向
                if (new_x < 0 || new_x >= m || new_y < 0 || new_y >= m || matrix[new_x][new_y] != nums[index + 1]) {
                    i += 1;
                    continue;
                }
                // 继续搜索下一位置
                if (dfs(new_x, new_y, index + 1, n, m, nums, matrix)) {
                    return true;
                }
            }
            i += 1;
        }

        matrix[x][y] = record;  // 回溯，恢复当前位置的值
        result = result.substring(0, result.length() - 4);  // 回溯，删除当前记录
        return false;  // 如果没有找到路径，返回 false
    }
}